home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / uemlsrc / file.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-08-24  |  16.6 KB  |  498 lines
  1. /*
  2.  * The routines in this file
  3.  * handle the reading and writing of
  4.  * disk files. All of details about the
  5.  * reading and writing of the disk are
  6.  * in "fileio.c".
  7.  */
  8. #include        <stdio.h>
  9. #include        "ed.h"
  10.  
  11. unsigned char   insflag = FALSE;        /* Flag for C mode in newline() */
  12.  
  13. /*
  14.  * Read a file into the current
  15.  * buffer. This is really easy; all you do it
  16.  * find the name of the file, and call the standard
  17.  * "read a file into the current buffer" code.
  18.  * Bound to "C-X C-R".
  19.  */
  20. fileread(f, n)
  21. register int f, n;
  22. {
  23.         register int    s;
  24.         char            fname[NFILEN];
  25.  
  26.         if ((s=mlreply("Read file: ", fname, NFILEN)) != TRUE)
  27.                 return (s);
  28.         return (readin(fname));
  29. }
  30.  
  31. /*
  32.  * Select a file for editing.
  33.  * Look around to see if you can find the
  34.  * file in another buffer; if you can find it
  35.  * just switch to the buffer. If you cannot find
  36.  * the file, create a new buffer, read in the
  37.  * text, and switch to the new buffer.
  38.  * Bound to C-X C-V.
  39.  */
  40. filevisit(f, n)
  41. register int f, n;
  42. {
  43.         register BUFFER *bp;
  44.         register WINDOW *wp;
  45.         register LINE   *lp;
  46.         register int    i;
  47.         register int    s;
  48.         char            bname[NBUFN];
  49.         char            fname[NFILEN];
  50.  
  51.         if ((s=mlreply("Visit file: ", fname, NFILEN)) != TRUE)
  52.                 return (s);
  53.         strcpy(lastbuf, curbp->b_bname);
  54.         for (bp=bheadp; bp!=NULL; bp=bp->b_bufp) {
  55.                 if ((bp->b_flag&BFTEMP)==0 && strcmp(bp->b_fname, fname)==0) {
  56.                         if (--curbp->b_nwnd == 0) {
  57.                                 curbp->b_dotp  = curwp->w_dotp;
  58.                                 curbp->b_doto  = curwp->w_doto;
  59.                                 curbp->b_markp = curwp->w_markp;
  60.                                 curbp->b_marko = curwp->w_marko;
  61.                         }
  62.                         curbp = bp;
  63.                         curwp->w_bufp  = bp;
  64.                         if (bp->b_nwnd++ == 0) {
  65.                                 curwp->w_dotp  = bp->b_dotp;
  66.                                 curwp->w_doto  = bp->b_doto;
  67.                                 curwp->w_markp = bp->b_markp;
  68.                                 curwp->w_marko = bp->b_marko;
  69.                         } else {
  70.                                 wp = wheadp;
  71.                                 while (wp != NULL) {
  72.                                         if (wp!=curwp && wp->w_bufp==bp) {
  73.                                                 curwp->w_dotp  = wp->w_dotp;
  74.                                                 curwp->w_doto  = wp->w_doto;
  75.                                                 curwp->w_markp = wp->w_markp;
  76.                                                 curwp->w_marko = wp->w_marko;
  77.                                                 break;
  78.                                         }
  79.                                         wp = wp->w_wndp;
  80.                                 }
  81.                         }
  82.                         lp = curwp->w_dotp;
  83.                         i = curwp->w_ntrows/2;
  84.                         while (i-- && lback(lp)!=curbp->b_linep)
  85.                                 lp = lback(lp);
  86.                         curwp->w_linep = lp;
  87.                         curwp->w_flag |= WFMODE|WFHARD;
  88.                         mlwrite("[Old buffer]");
  89.                         return (TRUE);
  90.                 }
  91.         }
  92.         makename(bname, fname);                 /* New buffer name.     */
  93.         while ((bp=bfind(bname, FALSE, 0)) != NULL) {
  94.                 s = mlreply("Buffer name: ", bname, NBUFN);
  95.                 if (s == ABORT)                 /* ^G to just quit      */
  96.                         return (s);
  97.                 if (s == FALSE) {               /* CR to clobber it     */
  98.                         makename(bname, fname);
  99.                         break;
  100.                 }
  101.         }
  102.         if (bp==NULL && (bp=bfind(bname, TRUE, 0))==NULL) {
  103.                 mlwrite("Cannot create buffer");
  104.                 return (FALSE);
  105.         }
  106.         if (--curbp->b_nwnd == 0) {             /* Undisplay.           */
  107.                 curbp->b_dotp = curwp->w_dotp;
  108.                 curbp->b_doto = curwp->w_doto;
  109.                 curbp->b_markp = curwp->w_markp;
  110.                 curbp->b_marko = curwp->w_marko;
  111.         }
  112.         curbp = bp;                             /* Switch to it.        */
  113.         curwp->w_bufp = bp;
  114.         curbp->b_nwnd++;
  115.         return (readin(fname));                 /* Read it in.          */
  116. }
  117.  
  118. /*
  119.  * Read file "fname" into the current
  120.  * buffer, blowing away any text found there. Called
  121.  * by both the read and visit commands. Return the final
  122.  * status of the read. Also called by the mainline,
  123.  * to read in a file specified on the command line as
  124.  * an argument.
  125.  */
  126. readin(fname)
  127. char    fname[];
  128. {
  129.         register LINE   *lp1;
  130.         register LINE   *lp2;
  131.         register int    i;
  132.         register WINDOW *wp;
  133.         register BUFFER *bp;
  134.         register int    s;
  135.         register int    nbytes;
  136.         register int    nline;
  137.         char            line[NLINE];
  138.  
  139.         bp = curbp;                             /* Cheap.               */
  140.         if ((s=bclear(bp)) != TRUE)             /* Might be old.        */
  141.                 return (s);
  142.         bp->b_flag &= ~(BFTEMP|BFCHG);
  143.         if (fname[0] == '~')                    /* an alias request */
  144.                 if ((s=parsefn(fname))==FALSE)
  145.                         s = FIOFNF;
  146.         strcpy(bp->b_fname, fname);
  147.         if ((s=ffropen(fname)) == FIOERR)       /* Hard file open.      */
  148.                 goto out;
  149.         if (s == FIOFNF) {                      /* File not found.      */
  150.                 mlwrite("[New file]");
  151.                 goto out;
  152.         }
  153.         mlwrite("[Reading %s]",fname);
  154.         nline = 0;
  155.         while ((s=ffgetline(line, NLINE)) == FIOSUC) {
  156.                 nbytes = strlen(line);
  157.                 if ((lp1=lalloc(nbytes)) == NULL) {
  158.                         s = FIOERR;             /* Keep message on the  */
  159.                         break;                  /* display.             */
  160.                 }
  161.                 lp2 = lback(curbp->b_linep);
  162.                 lp2->l_fp = lp1;
  163.                 lp1->l_fp = curbp->b_linep;
  164.                 lp1->l_bp = lp2;
  165.                 curbp->b_linep->l_bp = lp1;
  166.                 for (i=0; i<nbytes; ++i)
  167.                         lputc(lp1, i, line[i]);
  168.                 ++nline;
  169.         }
  170.         ffclose();                              /* Ignore errors.       */
  171.         if (s == FIOEOF) {                      /* Don't zap message!   */
  172.                 if (nline == 1)
  173.                         mlwrite("[Read %d line]",nline);
  174.                 else
  175.                         mlwrite("[Read %d lines]", nline);
  176.         }
  177. out:
  178.         for (wp=wheadp; wp!=NULL; wp=wp->w_wndp) {
  179.                 if (wp->w_bufp == curbp) {
  180.                         wp->w_linep = lforw(curbp->b_linep);
  181.                         wp->w_dotp  = lforw(curbp->b_linep);
  182.                         wp->w_doto  = 0;
  183.                         wp->w_markp = curwp->w_dotp;
  184.                         wp->w_marko = 0;
  185.                         wp->w_flag |= WFMODE|WFHARD;
  186.                 }
  187.         }
  188.         if (s == FIOERR)                        /* False if error.      */
  189.                 return (FALSE);
  190.         return (TRUE);
  191. }
  192.  
  193. /*
  194.  * Take a file name, and from it
  195.  * fabricate a buffer name. This routine knows
  196.  * about the syntax of file names on the target system.
  197.  * I suppose that this information could be put in
  198.  * a better place than a line of code.
  199.  */
  200. makename(bname, fname)
  201. char    bname[];
  202. char    fname[];
  203. {
  204.         register char   *cp1;
  205.         register char   *cp2;
  206.  
  207.         if (fname[0] == '~')
  208.                 parsefn(fname);
  209.         cp1 = &fname[0];
  210.         while (*cp1 != 0)
  211.                 ++cp1;
  212. #if     VMS
  213.         while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!=']')
  214.                 --cp1;
  215. #endif
  216. #if     CPM
  217.         while (cp1!=&fname[0] && cp1[-1]!=':')
  218.                 --cp1;
  219. #endif
  220. #if     ST
  221.         while (cp1!=&fname[0] && cp1[-1]!=':' && cp1[-1]!='\\')
  222.                 --cp1;
  223. #endif
  224. #if     V7
  225.         while (cp1!=&fname[0] && cp1[-1]!='/')
  226.                 --cp1;
  227. #endif
  228.         cp2 = &bname[0];
  229.         while (cp2!=&bname[NBUFN-1] && *cp1!=0 && *cp1!=';')
  230.                 *cp2++ = *cp1++;
  231.         *cp2 = 0;
  232. }
  233.  
  234. /*
  235.  * Ask for a file name, and write the
  236.  * contents of the current buffer to that file.
  237.  * Update the remembered file name and clear the
  238.  * buffer changed flag. This handling of file names
  239.  * is different from the earlier versions, and
  240.  * is more compatable with Gosling EMACS than
  241.  * with ITS EMACS. Bound to "C-X C-W".
  242.  */
  243. filewrite(f, n)
  244. register int f, n;
  245. {
  246.         register int    s;
  247.         char            fname[NFILEN];
  248.  
  249.         if ((s=mlreply("Write file: ", fname, NFILEN)) != TRUE)
  250.                 return (s);
  251.         if ((s=writeout(fname)) == TRUE) {
  252.                 strcpy(curbp->b_fname, fname);
  253.                 curbp->b_flag &= ~BFCHG;
  254.                 upmode();                       /* Update mode lines.   */
  255.         }
  256.         return (s);
  257. }
  258.  
  259. /*
  260.  * Save the contents of the current
  261.  * buffer in its associatd file. No nothing
  262.  * if nothing has changed (this may be a bug, not a
  263.  * feature). Error if there is no remembered file
  264.  * name for the buffer. Bound to "C-X C-S". May
  265.  * get called by "C-Z".
  266.  */
  267. filesave(f, n)
  268. register int f, n;
  269. {
  270.         register int    s;
  271.  
  272.         if ((curbp->b_flag&BFCHG) == 0)         /* Return, no changes.  */
  273.                 return (TRUE);
  274.         if (curbp->b_fname[0] == 0) {           /* Must have a name.    */
  275.                 filename(f,n);                  /* prompt user for a name */
  276.                 if (curbp->b_fname[0] == 0)     /* still no name        */
  277.                         return (FALSE);
  278.         }
  279.         if ((s=writeout(curbp->b_fname)) == TRUE) {
  280.                 curbp->b_flag &= ~BFCHG;
  281.                 upmode();                       /* Update mode lines.   */
  282.  
  283.         }
  284.         return (s);
  285. }
  286.  
  287. /*
  288.  * This function performs the details of file
  289.  * writing. Uses the file management routines in the
  290.  * "fileio.c" package. The number of lines written is
  291.  * displayed. Sadly, it looks inside a LINE; provide
  292.  * a macro for this. Most of the grief is error
  293.  * checking of some sort.
  294.  */
  295. writeout(fn)
  296. char    fn[];
  297. {
  298.         register int    s;
  299.         register LINE   *lp;
  300.         register int    nline;
  301.  
  302.         if (fn[0] == '~')                       /* an alias request */
  303.                 if ((s=parsefn(fn))==FALSE)
  304.                         return(FALSE);
  305.         if ((s=ffwopen(fn)) != FIOSUC)          /* Open writes message. */
  306.                 return (FALSE);
  307.         mlwrite("[Writing: %s]", fn);
  308.         lp = lforw(curbp->b_linep);             /* First line.          */
  309.         nline = 0;                              /* Number of lines.     */
  310.         while (lp != curbp->b_linep) {
  311.                 if ((s=ffputline(&lp->l_text[0], llength(lp))) != FIOSUC)
  312.                         break;
  313.                 ++nline;
  314.                 lp = lforw(lp);
  315.         }
  316.         if (s == FIOSUC) {                      /* No write error.      */
  317.                 s = ffclose();
  318.                 if (s == FIOSUC) {              /* No close error.      */
  319.                         if (nline == 1)
  320.                                 mlwrite("[Wrote %d line]",nline);
  321.                         else
  322.                                 mlwrite("[Wrote %d lines]", nline);
  323.                 }
  324.         } else                                  /* Ignore close error   */
  325.                 ffclose();                      /* if a write error.    */
  326.         if (s != FIOSUC)                        /* Some sort of error.  */
  327.                 return (FALSE);
  328.         return (TRUE);
  329. }
  330.  
  331. /*
  332.  * The command allows the user
  333.  * to modify the file name associated with
  334.  * the current buffer. It is like the "f" command
  335.  * in UNIX "ed". The operation is simple; just zap
  336.  * the name in the BUFFER structure, and mark the windows
  337.  * as needing an update. You can type a blank line at the
  338.  * prompt if you wish.
  339.  */
  340. filename(f, n)
  341. register int f, n;
  342. {
  343.         register int    s;
  344.         char            fname[NFILEN];
  345.  
  346.         if ((s=mlreply("Name: ", fname, NFILEN)) == ABORT)
  347.                 return (s);
  348.         if (fname[0] == '~')                    /* an alias request */
  349.                 s=parsefn(fname);
  350.         if (s == FALSE)
  351.                 strcpy(curbp->b_fname, "");
  352.         else
  353.                 strcpy(curbp->b_fname, fname);
  354.         upmode();
  355.         return (TRUE);
  356. }
  357.  
  358. /* WRITEREG eXtended command  Write defined region to file.  Prompt
  359.  * for filename.  Error if any sub-function returns failure. Bound to
  360.  * CTLX-R.
  361.  */
  362. writereg(f, n)
  363. register int f, n;
  364. {
  365.         register int    s;
  366.         char            buf[NLINE];
  367.         char            fname[NFILEN];
  368.  
  369.         n = 0;
  370.         f = 0;
  371.  
  372.         if ((s=mlreply("Write region: ", fname, NFILEN)) == ABORT || s == FALSE)
  373.                 return(s);
  374.         if (copyregion(NULL, NULL) != TRUE)
  375.                 return (FALSE);
  376.         if ((s=ffwopen(fname)) != FIOSUC)
  377.                 return (s);
  378.         while ((s=kremove(n++)) != EOF)
  379.                 {
  380.                 if (s != '\n' && f < NLINE)
  381.                         buf[f++] = s;
  382.                 else
  383.                         {
  384.                         ffputline(buf, f);
  385.                         f=0;
  386.                         }
  387.                 }
  388.         if ((s=ffclose()) == FIOERR)
  389.                 return(s);
  390.         else
  391.                 mlwrite("[Region written to %s]",fname);
  392.         return(TRUE);
  393. }
  394.  
  395. /* FILEINSERT  eXtended command insert existing file at point.  All of the
  396.  * necessary updating is done by the usual insert commands.  Bound to ^X-I.
  397.  */
  398.  
  399. fileinsert(f, n)
  400. register int f, n;
  401. {
  402.         char fname[NFILEN];
  403.         char line[NLINE];
  404.         register int c;
  405.         register int nline;
  406.         register int omarko;
  407.         register LINE *omarkp;
  408.  
  409.         nline = 0;
  410.  
  411.         if ((f=mlreply("Insert file: ", fname, NFILEN)) == ABORT || f == FALSE)
  412.                 return(f);
  413.         if (fname[0] == '~')
  414.                 if ((f=parsefn(fname))==FALSE)
  415.                         return(f);
  416.         if (ffropen(fname) == FIOFNF)
  417.                 {
  418.                 mlwrite("File: %s not found", fname);
  419.                 return (FALSE);
  420.                 }
  421.         insflag = TRUE;
  422.         /* save current place in buffer */
  423.         if ((omarkp=lback(curwp->w_dotp)) == curbp->b_linep)
  424.                 omarkp = NULL;
  425.         omarko = curwp->w_doto;
  426.         mlwrite("[Mark set]");
  427.         /* the standard routines take care of update */
  428.         while ((f=ffgetline(line, NLINE)) == FIOSUC)
  429.                 {
  430.                 n = 0;
  431.                 ++nline;
  432.                 while ((c=line[n++]) !=NULL)
  433.                         if (linsert(1, c) == FALSE)
  434.                                 {
  435.                                 insflag = FALSE;
  436.                                 return (FALSE);
  437.                                 }
  438.                 if (newline(FALSE, 1) == FALSE)
  439.                         {
  440.                         insflag = FALSE;
  441.                         return (FALSE);
  442.                         }
  443.                 }
  444.         ffclose();
  445.         if (f == FIOEOF)
  446.                 {
  447.                 if (nline == 1)
  448.                         mlwrite("[Inserted %d line]",nline);
  449.                 else
  450.                         mlwrite("[Inserted %d lines]", nline);
  451.                 }
  452.         insflag = FALSE;
  453.         /* The following code is needed if we want to insert a file
  454.          * the way GNU does (returning to the point of insertion
  455.          * when done).  The problem is with files inserted when the
  456.          * current point is at the end or beginning of the buffer.
  457.          */
  458.         if (omarkp == NULL)
  459.                 /* inserted at beginning */
  460.                 {
  461.                 curwp->w_markp = curwp->w_dotp;
  462.                 curwp->w_marko = curwp->w_doto;
  463.                 gotobob(FALSE,TRUE);
  464.                 curwp->w_doto = omarko;
  465.                 }
  466.         else
  467.                 /* inserted at end or in the midst */
  468.                 {
  469.                 curwp->w_markp = omarkp;
  470.                 curwp->w_marko = omarko;
  471.                 swapmark(FALSE,TRUE);
  472.                 forwline(NULL,1);
  473.                 }
  474.         if (f == FIOERR)
  475.                 return (FALSE);
  476.         return (TRUE);
  477. }
  478.  
  479. parsefn(fname)
  480. char fname[];
  481. {
  482.         register char   *ptr;
  483.         char            *index(), *alias();
  484.         char            template[NFILEN];
  485.  
  486.         if ((ptr=index(fname,'\\'))!=(char *)NULL)
  487.                 {
  488.                 *ptr = '\0';    /* ptr++==file; fname==alias */
  489.                 if (alias(&template[0],&fname[1])==(char *)NULL)
  490.                         return(FALSE);
  491.                 strcat(template,++ptr);
  492.                 strcpy(fname,template);
  493.                 }
  494.         else
  495.                 return(FALSE);
  496.         return(TRUE);
  497. }
  498.